package sanrenxing.reexams.dao.impl;

import sanrenxing.course.domain.CourseName;
import sanrenxing.reexams.dao.ReexamsDao;
import sanrenxing.reexams.domain.PaperAdd;
import sanrenxing.reexams.domain.PaperId;
import sanrenxing.reexams.domain.Reexams;
import sanrenxing.reexams.domain.ReexamsTo;
import sanrenxing.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * @description：
 * @auth：阳赛
 * @date:2020/8/25 0025 - 9:12
 * @version:1.0
 */
public class ReexamsDaoImpl implements ReexamsDao {

    /**
     *
     * @param reexams
     * @return
     */
    @Override
    public int add(Reexams reexams) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义影响行数的变量
        int rows=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="insert into reexams values(?,?,?)";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,reexams.getReexamsId());
            pstmt.setString(2,reexams.getStuId());
            pstmt.setInt(3,reexams.getCourseId());
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     *
     * @param reexamsId 补考编号主键
     * @return
     */
    @Override
    public int delete(int reexamsId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义影响行数的变量
        int rows=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="delete from reexams where reexamsId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,reexamsId);
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     *
     * @param reexams
     * @return
     */
    @Override
    public int update(Reexams reexams) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义影响行数的变量
        int rows=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="update reexams set reexamsId=?,stuId=?,courseId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,reexams.getReexamsId());
            pstmt.setString(2,reexams.getStuId());
            pstmt.setInt(3,reexams.getCourseId());
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     *
     * @param reexamsId
     * @return
     */
    @Override
    public Reexams findById(int reexamsId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的补考对象
        Reexams reexams=null;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select reexamsId,stuId,courseId from reexams where reexamsId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,reexamsId);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //判断结果集，并把结果集的数据封装到补考对象中
            if(rs.next()){
                //实例化补考对象
                reexams=new Reexams();
                //把结果集数据赋值给补考对象各属性
                reexams.setReexamsId(rs.getInt("reexamsId"));
                reexams.setStuId(rs.getString("stuId"));
                reexams.setCourseId(rs.getInt("courseId"));
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回补考对象
        return reexams;
    }

    /**
     *
     * @return
     */
    @Override
    public List<Reexams> findAll() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的补考对象集合
        List<Reexams> reexamsList=new ArrayList<Reexams>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select reexamsId,stuId,courseId from reexams";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到补考对象中
            while(rs.next()){
                //定义员工对象
                Reexams reexams=new Reexams();
                //把结果集数据赋值给补考对象各属性
                reexams.setReexamsId(rs.getInt("reexamsId"));
                reexams.setStuId(rs.getString("stuId"));
                reexams.setCourseId(rs.getInt("courseId"));
                reexamsList.add(reexams);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回补考对象集合
        return reexamsList;
    }

    /**
     *
     * @param rows 每页的行数
     * @param pages 页数
     * @return
     */
    @Override
    public List<Reexams> findByPage(int rows, int pages) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的补考对象集合
        List<Reexams> reexamsList=new ArrayList<Reexams>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select reexamsId,stuId,courseId from reexams limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给分页语句占位符赋值
            //分页语句：select * from 表名 limits (pages-1)*rows,rows
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到补考对象中
            while(rs.next()){
                //定义补考对象
                Reexams reexams=new Reexams();
                //把结果集数据赋值给补考对象各属性
                reexams.setReexamsId(rs.getInt("reexamsId"));
                reexams.setStuId(rs.getString("stuId"));
                reexams.setCourseId(rs.getInt("courseId"));
                //把补考对象添加补考集合中
                reexamsList.add(reexams);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回补考对象集合
        return reexamsList;
    }

    @Override
    public int count() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数据行数
        int rowCount=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select count(*) as reexamscount from reexams";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集，并获得总行数
            if(rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                rowCount=rs.getInt("reexamscount");
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回表中数据总行数
        return rowCount;
    }

    @Override
    public List<ReexamsTo> findByPage(int rows, int pages, String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的补考对象集合
        List<ReexamsTo> reexamsToList=new ArrayList<ReexamsTo>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="SELECT re.reexamsId,stu.stuName,c.courseName FROM reexams re JOIN student stu ON re.stuId=stu.stuId JOIN course c ON re.courseId=c.courseId" +
                    " where 1=1 "+condition+" limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给分页语句占位符赋值
            //分页语句：select * from 表名 limits (pages-1)*rows,rows
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到补考对象中
            while(rs.next()){
                //定义补考对象
                ReexamsTo reexamsTo=new ReexamsTo();
                //把结果集数据赋值给补考对象各属性
                reexamsTo.setReexamsId(rs.getInt("reexamsId"));
                reexamsTo.setStuName(rs.getString("stuName"));
                reexamsTo.setCourseName(rs.getString("courseName"));
                //把补考对象添加补考集合中
                reexamsToList.add(reexamsTo);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回补考对象集合
        return reexamsToList;
    }

    @Override
    public int count(String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数据行数
        int rowCount=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select count(*) as reexamscount from reexams re where 1=1 "+condition;
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集，并获得总行数
            if(rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                rowCount=rs.getInt("reexamscount");
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回表中数据总行数
        return rowCount;
    }

    @Override
    public String getCondition(Reexams reexams) {
        //定义查询条件字符串，初值为带空格的字符串(注意后续条件中的空格)
        String condition=" ";
        //如果补考对象为空，则直接返回空字符串
        if(reexams==null){
            return condition;
        }
        //如果补考编号不为0
        if(reexams.getReexamsId()!=0){
            condition += " and re.reexamsId="+reexams.getReexamsId();
        }
        //如果补考名不为空(字符串匹配模糊查询)
        if(reexams.getStuId()!=null && reexams.getStuId().trim().length()!=0){
            condition += " and re.stuId like '%"+reexams.getStuId()+"%' ";
        }
        //如果不为空
        if(reexams.getCourseId()!=0){
            condition += " and re.courseId="+reexams.getCourseId();
        }
        //返回条件字符串
        return condition;
    }

    /**
     * 通过学员姓名查询学员编号
     *
     * @param stuName
     * @return
     */
    @Override
    public String findStuId(String stuName) {
        //定义班级编号
        String stuId;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;


        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句
            String sql="SELECT  stuId FROM student where stuName=? ";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //占位符赋值
            pstmt.setString(1,stuName);
            //返回结果集
            rs=pstmt.executeQuery();
            if (rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                stuId=rs.getString("stuId");
                //返回stuId的值
                return stuId;
            }

        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return null;
    }

    /**
     * 通过学员姓名查询学员编号
     *
     * @param courseName
     * @return
     */
    @Override
    public int findCourseId(String courseName) {
        //定义课程编号
        int courseId;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义结果集
        ResultSet rs=null;


        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句
            String sql="SELECT  courseId FROM course where courseName=? ";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //占位符赋值
            pstmt.setString(1,courseName);
            //返回结果集
            rs=pstmt.executeQuery();
            if (rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                courseId=rs.getInt("courseId");
                //返回courseId的值
                return courseId;
            }

        } catch (SQLException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return 0;
    }

    /**
     * 查询所有试卷编号
     *
     * @return
     */
    @Override
    public List<PaperId> findPaperId() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集
        ResultSet rs=null;
        //定义一个集合
        List<PaperId> paperIdList=new ArrayList<>();


        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句
            String sql="select  paperId FROM paper";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //返回结果集
            rs=pstmt.executeQuery();
            while (rs.next()){
                //定义一个编号对象
                PaperId paperId=new PaperId();
                //如果统计行数时没有指定别名，则用数字0作为参数
                paperId.setPaperId (rs.getInt("paperId"));
                //返回结果集合
                paperIdList.add(paperId);
            }

        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回对象集合
        return paperIdList;
    }

    /**
     * 通过班级名称查询班级编号
     *
     * @param stuName 班级名称
     * @return
     */
    @Override
    public int findClassId(String stuName) {
        //定义一个班级编号
        int classId;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;


        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句
            String sql="SELECT  classId FROM student where stuName=? ";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setString(1,stuName);
            //返回结果集对象
            rs=pstmt.executeQuery();
            if (rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                classId=rs.getInt("classId");
                //返回班级编号
                return classId;
            }

        } catch (SQLException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return 0;
    }

    /**
     * 补考学员信息删除一行数据  考生状态表添加一行
     *
     * @param paperAdd
     * @return
     */
    @Override
    public int addStatu(PaperAdd paperAdd) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义影响行数的变量
        int rows=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="insert into statu(stuId,classId,paperId,conditions) values(?,?,?,?)";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQl语句的占位符赋值
            pstmt.setString(1,paperAdd.getStuId());
            pstmt.setInt(2,paperAdd.getClassId());
            pstmt.setInt(3,paperAdd.getPaperId());
            pstmt.setString(4,paperAdd.getConditions());
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }
}
